{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Guide to Orthomapping (Part 1)"]}, {"cell_type": "markdown", "metadata": {"toc": true}, "source": ["<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n", "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\">Introduction</a></span></li><li><span><a href=\"#Environment-Configuration\" data-toc-modified-id=\"Environment-Configuration-2\">Environment Configuration</a></span></li><li><span><a href=\"#Step-1.-Getting-Organized\" data-toc-modified-id=\"Step-1.-Getting-Organized-3\">Step 1. Getting Organized</a></span><ul class=\"toc-item\"><li><span><a href=\"#1.1-Create-image-collection\" data-toc-modified-id=\"1.1-Create-image-collection-3.1\">1.1 Create image collection</a></span><ul class=\"toc-item\"><li><span><a href=\"#1.1.1-Create-a-project-folder\" data-toc-modified-id=\"1.1.1-Create-a-project-folder-3.1.1\">1.1.1 Create a project folder</a></span></li><li><span><a href=\"#1.1.2-Upload-images-into-the-project-folder\" data-toc-modified-id=\"1.1.2-Upload-images-into-the-project-folder-3.1.2\">1.1.2 Upload images into the project folder</a></span></li><li><span><a href=\"#1.1.3-Get-image-GPS-information-and-camera-properties\" data-toc-modified-id=\"1.1.3-Get-image-GPS-information-and-camera-properties-3.1.3\">1.1.3 Get image GPS information and camera properties</a></span></li><li><span><a href=\"#1.1.4-Create-an-image-collection-Imagery-Layer-item\" data-toc-modified-id=\"1.1.4-Create-an-image-collection-Imagery-Layer-item-3.1.4\">1.1.4 Create an image collection Imagery Layer item</a></span></li></ul></li></ul></li><li><span><a href=\"#References\" data-toc-modified-id=\"References-4\">References</a></span></li></ul></div>"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Introduction\n", "\n", "Welcome to the Part 1 of the series of guides to Orthomapping! Here, you will be exposed to the concepts of OrthoMapping, how to set up the environment as to perform orthomapping analysis, and steps to create image collections.\n", "\n", "If you are new to orthomapping, or you need some refresher to the concepts, the video link below titled `Ortho Mapping in ArcGIS Pro` (discoverable on YouTube) could be a good source to begin with:"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"image/jpeg": "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\n", "text/html": ["\n", "        <iframe\n", "            width=\"400\"\n", "            height=\"300\"\n", "            src=\"https://www.youtube.com/embed/-wmJmNGBFuc\"\n", "            frameborder=\"0\"\n", "            allowfullscreen\n", "        ></iframe>\n", "        "], "text/plain": ["<IPython.lib.display.YouTubeVideo at 0x2514b623d68>"]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["from IPython.display import YouTubeVideo\n", "YouTubeVideo('-wmJmNGBFuc')"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Remote sensing images like a drone image, aerial photograph, or data from a satellite sensor, will inevitably be impacted by some form of geometric distortion. The shape of local terrain, the sensor angle and altitude, the motion of the sensor system, and the curvature of the Earth all make it difficult to represent three dimensional ground features accurately in a two dimensional map. For instance, distortion caused by camera tilt or terrain displacement can be seen in Fig 1 <a href='#References'>[1]</a>. The key to make a measurable, map-accurate image is to apply `Image orthorectification`, which corrects for these types of distortion <a href='#References'>[2]</a>."]}, {"cell_type": "markdown", "metadata": {}, "source": ["<img align=\"left\" src=\"\" />"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Fig 1. Distortion caused by camera tilt (left) and terrain displacement (right) (source: <a href='#References'>[1]</a>). "]}, {"cell_type": "markdown", "metadata": {}, "source": ["`Orthomapping` is a combined process of orthorectification and mapping, in which `Orthorectification` refers to the removal of geometric distortion introduced by the platform, sensor, and especially terrain displacement, and `Mapping` refers to the edgematching, seamlines generation, and color balancing of multiple images to produce an `orthomosaic` dataset.\n", "\n", "\"This orthomosaic is accurate to a specified map scale accuracy and can be used to make measurements as well as generate and update GIS feature class layers. To accomplish this, you need imagery with known sensor positions, attitudes, and a calibrated geometric model for the sensor along with a digital terrain model (DTM)\", as stated in Esri's help documentation <a href='#References'>[2]</a>. \n", "\n", "Orthorectified image datasets, seamless orthoimage mosaic datasets stored as a file format such as TIFF or CRF, or digital terrain models (DTM) and digital surface models (DSM) are all classified as orthomapping products <a href='#References'>[3]</a>. And the process of generating orthomapping products is summarized in the figure below."]}, {"cell_type": "markdown", "metadata": {}, "source": ["<img src=\"\" align=\"left\" />"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Fig 2. Workflow of generating orthomapping products (source: <a href='#References'>[3]</a>).\n", "\n", "As for the usage of orthorectified mosaic dataset, it can be shared as dynamic image services or cached image services, or can be used to generate additional orthorectified products, such as `Image tiles`, or `Ortho image scenes` <a href='#References'>[3]</a>.\n", "\n", "The advantage of the orthoimage is also revealed in the help documentation, that \"it contains all the information visible in the imagery, not just the features and GIS layers extracted from the image and symbolized on a map\" <a href='#References'>[2]</a>. One of the examples being given is that, a road symbolized on a map has uniform width, whereas a road on the orthoimage has variable width and shoulders that allow emergency vehicles to navigate traffic jams or store building material and equipment.\n", "\n", "With your remote sensing imagery being orthorectified, and map-accurate, or other products like orthomosaics (mosaicked images corrected for distortion) and digital elevation models (terrain or surface models) created, you can then further extend their usage as basemaps, part of a landbase, or for further analysis in stereo models, 3D analysis and feature extraction <a href='#References'>[1]</a>."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Environment Configuration\n", "\n", "**Important Notes**: \n", "\n", " - The ability to perform Orthomapping with ArcGIS Python API is available at ArcGIS Enterprise 10.6.1 through ArcGIS API for Python version 1.4.2. It is not yet available on ArcGIS Online.\n", "\n", " - The ArcGIS Enterprise needs to be configured with a raster analysis server, which requires an Image Server license.\n", " \n", "In order to meet the requirements, your configured enterprise needs to be installed with ArcGIS Enterprise (version >= 10.6.1), and your work environment has to be installed with ArcGIS API for Python (version >= 1.4.2); also, a raster analysis server which is privileged with an Image Server license has to be federated into your configured enterprise. \n", "\n", "The two variables `is_support_orthomapping` and `is_support_rasteranalytics` will be False if failing to meet the requirements. In that case, the sample notebook cannot be continued."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["import os\n", "import glob\n", "import ntpath\n", "import arcgis\n", "from arcgis.gis import GIS"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Connect to GIS."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": ["portal_url = \"https://yourportal.domain.com/portal\"\n", "portal_username = \"your username\"\n", "portal_password = \"your password\"\n", "\n", "gis = GIS(url=portal_url, username=portal_username, password=portal_password)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Ensure that Orthomapping and Raster Analytics are supported in our ArcGIS Enterprise."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 3, "metadata": {}, "output_type": "execute_result"}], "source": ["is_support_orthomapping = arcgis.raster.orthomapping.is_supported(gis)\n", "is_support_orthomapping"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["True"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["is_support_rasteranalytics = arcgis.raster.analytics.is_supported(gis)\n", "is_support_rasteranalytics"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now that we have a valid configured environment, let's proceed to the following four steps:\n", " - __Step 1. Getting Organized__, in which we will discuss how to create image collection layer item from multiple images. Please stay with us in this part 1 of the guide to learn more about it.\n", " - __Step 2. Getting Adjusted__, that will introduce how to apply block adjustments, manipulate control points, and compute seamlines and color correction. If you already know how to create image collections and want to skip Step 1, feel free to jump directly to the second part of the guide to get started with Step 2 (<a href=\"./orthomapping-guide-2\">Jump to Step 2</a>).\n", " - __Step 3. Getting Results__, in which we will talk about procedures in generating orthomosaic, DEM, and Vegetation Indices through orthomapping tools (<a href=\"./orthomapping-guide-2\">Jump to Step 3</a>).\n", " - __Step 4. Managing Imageries__, that will demonstrate how to add/delete images in the image collection, and reset/delete the image collection (<a href=\"./orthomapping-guide-3\">Jump to Step 4</a>)."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Step 1. Getting Organized"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### 1.1 Create image collection"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The orthomapping workflow starts from creating an image collection with the images of our study area. \n", "\n", "The __[arcgis.raster.analytics.create_image_collection()](https://developers.arcgis.com/python/api-reference/arcgis.raster.analytics.html#create-image-collection)__ task takes multiple image items as input and creates a mosaic dataset in registered raster store. Then, it creates an image collection imagery layer out of it. The function takes raster type name and raster type parameters which will be used to add images to the image collection.\n", "\n", "Following script also shows additional steps to upload the images to the portal, get the GPS information, etc. "]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### 1.1.1 Create a project folder"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["prj_folder_name = \"myOrthomappingProject\"\n", "prj_folder_item = gis.content.create_folder(folder=prj_folder_name, owner=portal_username)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### 1.1.2 Upload images into the project folder"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The study site (as shown in Fig 3) has been selected at the Yucaipa Valley Water District (located at 34\u00b000'25.6\"N 117\u00b005'47.8\"W) in Calimesa, CA, and the 13 Drone images were taken here with a controlled route. Drone2Map images are placed inside the folder path `imageFolderPath` before running the cell below.\n", "\n", "<img src=\"\" />\n", "Fig 3. This layer presents low-resolution satellite imagery for the world and high-resolution satellite and aerial imagery, typically within 3-5 years of currency, for most of the world (Credits: Esri LivingAtlas)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["With multiple imageries stored in a folder, the cell below is to upload the images from local folder to enterprise, and save the URL references to these uploaded images as a list variable."]}, {"cell_type": "code", "execution_count": 6, "metadata": {"scrolled": false}, "outputs": [], "source": ["image_folder_path = r\"\\\\folder\\path\\to\\images\\orthomapping\\YVWD_13\"\n", "image_list = glob.glob(os.path.join(image_folder_path, '*.JPG'))\n", "image_item_list = []\n", "item_prop_template = {\"type\": \"Image\"}\n", "\n", "for image_full_path in image_list:\n", "    image_name = ntpath.split(image_full_path)[1]\n", "    item_prop_template[\"title\"] = image_name\n", "    item_prop_template[\"tags\"] = image_name\n", "    item_prop_template[\"description\"] = image_name\n", "\n", "    image_item = gis.content.add(item_properties=item_prop_template, data=image_full_path, \n", "                                owner=portal_username, folder=prj_folder_name)\n", "    image_item_list.append(image_item)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### 1.1.3 Get image GPS information and camera properties"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Camera GPS coordinates when taking each image are needed to create image collection. This information can be stored in various image auxiliary files. For data used in this sample notebook, the GPS data is stored in EXIF (Exchangeable Image File) of the images. \n", "\n", "Import the `exifread` library below, and we will define a function that utilizes the exifread library to get location information out of the images. These coordinates would be used in the analysis later."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": ["import exifread"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The latitude is preceded by a minus sign if it is south of the equator (a positive number implies north), the longitude is preceded by a minus sign if it is west of the prime meridian (a positive number implies east), and the altitude is preceded by a minus sign if it is below sea level (a positive number implies above sea level)."]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": ["def find_lat_long_alt_ref(tag, tags, value):\n", "    latitude_ref = tags.get('GPS GPSLatitudeRef')\n", "    if tag == \"GPS GPSLatitude\":\n", "        if latitude_ref.values != 'N':\n", "            value = -value\n", "        return value\n", "    longtitude_ref = tags.get('GPS GPSLongitudeRef')\n", "    if tag == \"GPS GPSLongitude\":\n", "        if longtitude_ref.values != 'E':\n", "            value = -value\n", "        return value\n", "    altitude_ref = tags.get('GPS GPSAltitudeRef')\n", "    if tag == \"GPS GPSAltitude\":\n", "        if altitude_ref.values == 1:\n", "            value = -value\n", "        return value"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Function to convert degrees, minutes, seconds to decimal degrees."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": ["def convert_to_degrees(d,m,s):\n", "    return d+(m/60)+(s/3600)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Function to find latitude, longitude, and altitude values."]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": ["def find_lat_long_alt(image, tag_ref):\n", "    f=[]\n", "    tags=[]\n", "    f = open(image, 'rb')\n", "    tags = exifread.process_file(f)\n", "    for tag in tags:\n", "        if tag in ('GPS GPSLatitude') and tag_ref == tag:\n", "            lat_degree = tags[tag] \n", "            d = float(lat_degree.values[0].num) / float(lat_degree.values[0].den)\n", "            m = float(lat_degree.values[1].num) / float(lat_degree.values[1].den)\n", "            s = float(lat_degree.values[2].num) / float(lat_degree.values[2].den)\n", "            lat_degrees = convert_to_degrees(d,m,s)\n", "            lat_degrees = find_lat_long_alt_ref(tag, tags, lat_degrees)\n", "            return lat_degrees\n", "        if tag in ('GPS GPSLongitude') and tag_ref == tag:\n", "            long_degree = tags[tag] \n", "            d = float(long_degree.values[0].num) / float(long_degree.values[0].den)\n", "            m = float(long_degree.values[1].num) / float(long_degree.values[1].den)\n", "            s = float(long_degree.values[2].num) / float(long_degree.values[2].den)\n", "            long_degrees = convert_to_degrees(d,m,s)\n", "            long_degrees = find_lat_long_alt_ref(tag, tags, long_degrees)\n", "            return long_degrees\n", "        if tag in ('GPS GPSAltitude') and tag_ref == tag:\n", "            altitude = tags[tag] \n", "            altitude_meter = float(altitude.values[0].num) / float(altitude.values[0].den)\n", "            altitude_meter = find_lat_long_alt_ref(tag, tags, altitude_meter)\n", "            return altitude_meter"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Construct the GPS array structure - [[imageName1, gpsLatitude1, gpsLongtitude1, gpsAltitude1]...]"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": ["gps = [[ntpath.split(image)[1], \n", "        find_lat_long_alt(image, 'GPS GPSLatitude'), \n", "        find_lat_long_alt(image, 'GPS GPSLongitude'),\n", "        find_lat_long_alt(image, 'GPS GPSAltitude')] for image in image_list]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Construct the camera properties dictionary structure - `{\"maker\",\"model\",\"focallength\",\"columns\",\"rows\",\"pixelsize\"}`.\n", "We can query camera database with __[arcgis.raster.orthomapping.query_camera_info()](https://developers.arcgis.com/python/api-reference/arcgis.raster.orthomapping.html#query-camera-info)__ \n", "\n", "In this example, we will query for only those of camera make equals to \"Yuneec\":"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>Make</th>\n", "      <th>Model</th>\n", "      <th>Focallength</th>\n", "      <th>Columns</th>\n", "      <th>Rows</th>\n", "      <th>PixelSize</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>Yuneec</td>\n", "      <td>E90</td>\n", "      <td>8.0</td>\n", "      <td>5472</td>\n", "      <td>3648</td>\n", "      <td>0.0024</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["     Make Model Focallength Columns  Rows PixelSize\n", "0  Yuneec   E90         8.0    5472  3648    0.0024"]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["arcgis.raster.orthomapping.query_camera_info(camera_query=\"Make='Yuneec'\")"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["camera_properties = {\"maker\":\"Yuneec\",\"model\":\"E90\",\"focallength\":8,\"columns\":5472,\"rows\":3648,\"pixelsize\":0.0024}"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**Note**: Orthomapping workflow requires to perform block adjustment for image collection at a later compute sensor model step. It relies on camera properties and camera GPS (x, y, z) when taking the images. Regarding the \"z\", what the underlying algorithm actually needs is the flying height information. So, it requires ground elevation data with \"averagezdem\" or \"constantz\" parameter to perform the additional subtraction.\n", "\n", "If these \"DEM\" related parameters are not set, by default, it will use orthomapping elevation utility service in our ArcGIS Enterprise to perform block adjustment."]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["raster_type_params = {\n", "    \"gps\": gps, \"cameraProperties\": camera_properties, \"isAltitudeFlightHeight\": \"False\",\n", "    \"averagezdem\":{\n", "        \"url\":\"https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer\"\n", "    }\n", "}"]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/plain": ["{'gps': [['YUN_0044.JPG', 34.0070879, -117.09416449999999, 725.18],\n", "  ['YUN_0045.JPG', 34.007113099722226, -117.09450929972222, 725.36],\n", "  ['YUN_0046.JPG', 34.0071384, -117.09485779972222, 725.21],\n", "  ['YUN_0076.JPG', 34.00668639972222, -117.09463709972222, 725.37],\n", "  ['YUN_0077.JPG', 34.00666089972222, -117.09428809972222, 725.31],\n", "  ['YUN_0078.JPG', 34.00663709972222, -117.09395939999999, 725.23],\n", "  ['YUN_0079.JPG', 34.0066113, -117.09360669972222, 725.31],\n", "  ['YUN_0080.JPG', 34.00658549972222, -117.09325299999999, 725.35],\n", "  ['YUN_0081.JPG', 34.0065606, -117.0929043, 725.18],\n", "  ['YUN_0040.JPG', 34.0069887, -117.09279029999999, 725.13],\n", "  ['YUN_0041.JPG', 34.0070131, -117.09311519972222, 725.0],\n", "  ['YUN_0042.JPG', 34.0070381, -117.09346329972222, 725.12],\n", "  ['YUN_0043.JPG', 34.00706339972222, -117.09381479999999, 725.2]],\n", " 'cameraProperties': {'maker': 'Yuneec',\n", "  'model': 'E90',\n", "  'focallength': 8,\n", "  'columns': 5472,\n", "  'rows': 3648,\n", "  'pixelsize': 0.0024},\n", " 'isAltitudeFlightHeight': 'False',\n", " 'averagezdem': {'url': 'https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer'}}"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["raster_type_params"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### 1.1.4 Create an image collection Imagery Layer item"]}, {"cell_type": "code", "execution_count": 16, "metadata": {"scrolled": true}, "outputs": [], "source": ["from arcgis.raster.analytics import create_image_collection\n", "image_collection_name = \"omImageCollection\"\n", "image_collection_item = create_image_collection(image_collection=image_collection_name,\n", "                                                input_rasters=image_item_list,\n", "                                                raster_type_name=\"UAV/UAS\",\n", "                                                raster_type_params=raster_type_params,\n", "                                                folder=prj_folder_name)"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/plain": ["'https://yourportal.domain.com/server/rest/services/Hosted/omImageCollection/ImageServer'"]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["image_collection_item.url"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["<img src=\"\"/>"], "text/plain": ["<IPython.core.display.Image object>"]}, "execution_count": 1, "metadata": {}, "output_type": "execute_result"}], "source": ["image_collection_item.layers[0]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Now we have finished creating an Imagery Collection Layer Item, let's move onto Step 2 (Getting Adjusted) and Step 3 (Getting Results) in <a href='orthomapping_guide_2.ipynb'>Part 2</a>."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## References\n", "\n", "<a href=\"#Introduction\">[1]</a> Lenhardt & Liedtke, Ortho Mapping in ArcGIS Pro Part I: Getting Organized with a Workspace, https://www.esri.com/arcgis-blog/products/arcgis-pro/imagery/ortho-mapping-workspace/ [Online] [Assessed on August 13, 2019]\n", "\n", "<a href=\"#Introduction\">[2]</a> Introduction to orthomapping, https://pro.arcgis.com/en/pro-app/help/data/imagery/introduction-to-ortho-mapping.htm [Online] [Assessed on August 9, 2019]\n", "\n", "<a href=\"#Introduction\">[3]</a> Ortho mapping in ArcGIS Pro, https://pro.arcgis.com/en/pro-app/help/data/imagery/ortho-mapping-in-arcgis-pro.htm [Online] [Assessed on August 13, 2019]"]}], "metadata": {"celltoolbar": "Raw Cell Format", "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.10"}, "toc": {"base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": true, "skip_h1_title": true, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": true, "toc_position": {}, "toc_section_display": true, "toc_window_display": false}, "varInspector": {"cols": {"lenName": 16, "lenType": 16, "lenVar": 40}, "kernels_config": {"python": {"delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())"}, "r": {"delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) "}}, "types_to_exclude": ["module", "function", "builtin_function_or_method", "instance", "_Feature"], "window_display": false}}, "nbformat": 4, "nbformat_minor": 2}